OCL Conversion to Schematron (xslt2 query binding)

self

The current object in the context of which the expression shall hold.

current()

t defined in an iterator used in x(t)

t has to be assigned a value from the path that leads to x(t).

$t

t defined in a let construct used in x(t)

t necessarily has a value from the initialize expression.

If t is defined in the outer (current()) context: $id, where id is some unique <let> variable. The let initializer is translated in the current() context and initializes a Schemtron <let> element.

Other: The let initializer of the variable t is translated in the current context and substitutes t.

let x=y in z(x)

Assignment of expression y to variable x. Result is z(x).

If x and y are defined in the outer (current()) context: τ(z(τ(x)))
Additionally, a Schematron <let> is created.

Other: τ(z(τ(y)))
This means we are substituting the initializers.

123 or 3.1415

same, i.e.: 123 or 3.1415

true or false

true() or false()

'xxxxx'

same, i.e.: 'xxxxx'

Type::value

'value'

Type::value

GML 3.3 rules:
The constant is translated to an external codelist reference according to a pattern in tagged values in the codelist class.

Other GML version rules: 'value'

if x then y else z endif

If x evaluates to true then the value of the expression is y, otherwise z.

if τ(x) then τ(y) else τ(z)

x . property

Collection of property values reached from the instance or collection repre­sented by x by applying property property.

x . property. value
x . property. reason

Set of instances reached by property, respectively by property/@nilReason

x. propertyMetadata()

Access the metadata associated with the property, instead of the property value.

x . allInstances()

Collection of all object instances of type x.

x represents a type-valued expression.

If x is a type constant:
An expression that selects all elements based upon a predicate which uses a combination of local-names and namespace-uris of the type and its (direct and indirect) subtypes (if they are instantiable, i.e. not abstract and not suppressed). We differentiate three cases:

If x is a type expression:
Cannot be translated because required schema information is not available at run-time.

x . oclIsKindOf(y)

The single object instance x is checked for complying with type y.

If y is a type constant:
boolean(τ(x)[(local-name()='localName_T1' and namespace-uri()='namespace_T1') or … or (local-name()='localName_Ti' and namespace-uri()='namespace_Ti')]), where Tk is one of the concrete derivations of y, including y.

If y is a type expression: Cannot be translated because required schema information is not available at run-time.

x . oclIsTypeOf(y)

The single object instance x is checked for being of type y.

If y is a type constant: boolean(τ(x) [local-name()='localName_y' and namespace-uri()='namespace_y']).  

boolean(…) may be omitted if the argument is known to be used by operands, which do an implicit conversion to Boolean.

If x is a type expression:
Cannot be translated because required schema information is not available at run-time.

x . oclAsType(y)

The single object instance x is downcast to type y. The value is 'undefined' if this is not possible.

If y is a type constant:
τ(x) [(local-name()='localName_T1' and namespace-uri()='namespace_T1') or … or (local-name()='localName_Ti' and namespace-uri()='namespace_Ti')], where Tk is one of the concrete derivations of y, including y.

If y is a type expression: Cannot be translated because required schema information is not available at run-time.

Casting CharacterString to a code list: We are making an exception to the strict rules with simple data elements. We permit CharacterString being cast to a code list type.

x + y, etc.

Value of x + y, etc.

τ(x) + τ(y)
τ(x) – τ(y)
τ(x) * τ(y)
τ(x) div τ(y)

x = y
x <> y

Value of x=y, x<>y

If x and y are simple types:

If x and y are complex types:

x < y, etc.

Value of x < y, etc.

x . size()

Number of characters in the string instance x.

string-length(τ(x))

x . concat(y)

String concatenation of x and y.

concat(τ(x),τ(y))
A series of concats may be joined to a multi-argument concat invocation.

x . substring(y,z)

Substring of x running from position y to position z.

More specifically: the sub-string of x starting at the character number y, up to and including character number z. Character numbers run from 1 to x.size(). The following condition should be met: 1 <= y <= z <= x.size().

substring(τ(x), τ(y), τ(z)-τ(y)+1)

Logical combination as indicated

x -> size()

Number of objects in the collection x.

count(τ(x))

x->isEmpty()

Predicate: Is the collection represented by x empty?

not(τ(x))

x->notEmpty()

Predicate: Is the collection represented by x not empty?

boolean(τ(x))

x -> exists(t|b(t))

Predicate: Does the collection x contain a value t for which the boolean expression b(t) holds?

some $t in τ(x) satisfies τ(b(t))

x -> forAll(t|b(t))

Predicate: Does the collection x only contain values t for which the boolean expression b(t) holds?

every $t in τ(x) satisfies τ(b(t))

x -> isUnique(t|y(t))

Determine if y(t) evaluates to a different, possibly null, value for each element in the source collection x.

If y(t) equals t, then uniqueness of the values in the collection x is checked.

This can only be translated in a few cases:

x -> select(t|b(t))

Compute the collection of those objects t in x, for which the boolean expression b(t) holds.

τ(x) [for $t in . return τ(b(t))]

x . matches( pattern )

Boolean function which yields true if the pattern of type String matches the String argument.

matches( τ(x), τ(pattern) )